home *** CD-ROM | disk | FTP | other *** search
/ The Games Machine 35 / The Games Machine - Ita - CD-ROM Vol.35 / dkedemo it.iso / ALEXDEMO / DATA.Z / BASICMAN.AI < prev    next >
Encoding:
Text File  |  1997-05-28  |  28.8 KB  |  1,193 lines
  1. import "constant.ai";
  2.  
  3. ' Forward declarations
  4. procedure AttackInZOC(movingUnit);
  5. procedure ShootMissiles(shootingUnit);
  6. procedure Defend(hexToDefend);
  7. procedure RecoverUnits();
  8. procedure RecoverAnyUnit();
  9. procedure Rally();
  10. procedure PartialRecover();
  11. procedure GetUnitsInRange(list);
  12. procedure GetUnitsOutOfRange(list);
  13. procedure MoveLeader();
  14. procedure EnemyWithinRangeOfGroup(radius);
  15. procedure ShootMissilesFar(unitToFire);
  16. procedure CommandOtherUnits();
  17. procedure NoMoreUnitsToCommand();
  18. procedure TurnToDefend();
  19. procedure GetUnitsToCommand(legalList);
  20.  
  21. ' GetFrontalFacings takes a list id and a facing (direction).  It fills the
  22. ' list with the (2) directions of that a unit can go.  It returns 1 if the
  23. ' original facing is correct, otherwise it returns 0.  (NORTH and SOUTH are
  24. ' NOT valid facings).
  25. procedure GetFrontalFacings(listID, facing)
  26. {
  27.     var retVal;
  28.  
  29.     retVal = 0;
  30.     if (facing == NORTHEAST)
  31.     {
  32.         AddToList(listID, NORTH);
  33.         AddToList(listID, NORTHEAST);
  34.         retVal = 1;
  35.     };
  36.     if (facing == EAST)
  37.     {
  38.         AddToList(listID, NORTHEAST);
  39.         AddToList(listID, SOUTHEAST);
  40.         retVal = 1;
  41.     };
  42.     if (facing == SOUTHEAST)
  43.     {
  44.         AddToList(listID, SOUTHEAST);
  45.         AddToList(listID, SOUTH);
  46.         retVal = 1;
  47.     };
  48.     if (facing == SOUTHWEST)
  49.     {
  50.         AddToList(listID, SOUTH);
  51.         AddToList(listID, SOUTHWEST);
  52.         retVal = 1;
  53.     };
  54.     if (facing == WEST)
  55.     {
  56.         AddToList(listID, SOUTHWEST);
  57.         AddToList(listID, NORTHWEST);
  58.         retVal = 1;
  59.     };
  60.     if (facing == NORTHWEST)
  61.     {
  62.         AddToList(listID, NORTHWEST);
  63.         AddToList(listID, NORTH);
  64.         retVal = 1;
  65.     };
  66.     return retVal;
  67. };
  68.  
  69. ' inProximity looks at the identifying hex lists (flank, rear, or frontal)
  70. ' to see if the hex in question is in that list.  It returns TRUE if it is,
  71. ' otherwise it returns FALSE.  For the identifying list types it is:
  72. ' 0 = ZOC
  73. ' 1 = flank
  74. ' 2 = rear
  75. procedure inProximity(hexInQuestion, nation, hexType)
  76. {
  77.     var dir, hex, hexList, retVal, unit, n, isLeader;
  78.  
  79.     retVal = FALSE;
  80.  
  81.     for dir = NORTH to NORTHWEST
  82.     {
  83.         hex = AdjacentHex(hexInQuestion, dir);
  84.         if (hex != -1)
  85.         {
  86.             unit = HexOccupancy(hex);
  87.             if (unit!=-1)
  88.             {
  89.                 isLeader = IsLeader(unit);
  90.                 if (NOT isLeader)
  91.                 {
  92.                     n = Query(NATION, unit);
  93.                     if (n != nation)
  94.                     {
  95.                         hexList = GetList();
  96.                         AssignList(hexList, hexType, unit);    ' Assign flank hexes
  97.                         if (IsMemberOf(hexList, hexInQuestion))
  98.                             retVal = TRUE;
  99.                     };
  100.                     ' ReleaseList(hexList);
  101.                 };
  102.             };
  103.         };
  104.     };
  105.     return retVal;
  106. };
  107.  
  108. '**************************************************************************
  109. ' InFlank checks to see if the hex in question is in the flank of an enemy
  110. ' unit.
  111. procedure InFlank(hexInQuestion, nation)
  112. {
  113.     return inProximity(hexInQuestion, nation, 1);    ' 1 identifies flank hexes
  114. };
  115.  
  116. '**************************************************************************
  117. ' InRear checks to see if the hex in question is in the rear of an enemy
  118. ' unit.
  119. procedure InRear(hexInQuestion, nation)
  120. {
  121.     return inProximity(hexInQuestion, nation, 2);    ' 2 identifies rear hexes
  122. };
  123.  
  124. '**************************************************************************
  125. ' InFrontal checks to see if the hex in question is in the frontal of an
  126. ' enemy unit.
  127. procedure InFrontal(hexInQuestion, nation)
  128. {
  129.     return inProximity(hexInQuestion, nation, 0);    ' 0 identifies frontal hexes
  130. };
  131.  
  132. '**************************************************************************
  133. ' WeightCombatPath looks at the path of a combat unit and weights it
  134. ' according to the following:
  135. ' Clear = 9
  136. ' Rear = 7
  137. ' Flank = 5
  138. ' Frontal = 2
  139. ' DS = 0
  140. ' These values may be modified in the CONSTANT.AI file.
  141. ' Currently (7/31/96), only the final hex in the path is looked at.  That
  142. ' may change to be every hex is looked at.
  143. procedure WeightCombatPath(pathID, nation)
  144. {
  145.     var hexInQuestion, weight, w;
  146.  
  147.     ' Assume the path is going to be clear.
  148.     weight = CLEAR;
  149.  
  150.     hexInQuestion = GetLast(pathID);
  151.     w = InFlank(hexInQuestion, nation);
  152.     if (w == TRUE)
  153.     {
  154.         weight = FLANK;
  155.     };
  156.     ' A rear attack would be much more desirable than a flank attack so that
  157.     ' why it is checked for after the flank
  158.     if (InRear(hexInQuestion, nation) == TRUE)
  159.     {
  160.         weight = REAR;
  161.     };
  162.     ' A frontal attack is the least desirable but it needs to be checked for
  163.     ' last since it is something that the unit would not want to move into
  164.     if (InFrontal(hexInQuestion, nation) == TRUE)
  165.     {
  166.         weight = FRONTAL;
  167.     };
  168.  
  169.     return weight;
  170. };
  171.  
  172. procedure GenericMove(hex);
  173.  
  174. procedure PersianFlankingPosAcheived(hex)
  175. {
  176.     var unit, retVal, n;
  177.  
  178.     unit = HexOccupancy(hex);
  179.     retVal = False;
  180.  
  181.     if (unit != -1)
  182.     {
  183.         n = Query(NATION, unit);
  184.         if (n == PERSIAN)
  185.             retVal = True;
  186.     };
  187.     return retVal;
  188. };
  189.  
  190. procedure IndianFlankingPosAcheived(hex)
  191. {
  192.     var unit, retVal, n;
  193.  
  194.     unit = HexOccupancy(hex);
  195.     retVal = False;
  196.  
  197.     if (unit != -1)
  198.     {
  199.         n = Query(NATION, unit);
  200.         if (n == INDIAN)
  201.             retVal = True;
  202.     };
  203.     return retVal;
  204. };
  205.  
  206. procedure DanubianFlankingPosAcheived(hex)
  207. {
  208.     var unit, retVal, n;
  209.  
  210.     unit = HexOccupancy(hex);
  211.     retVal = False;
  212.  
  213.     if (unit != -1)
  214.     {
  215.         n = Query(NATION, unit);
  216.         if (n == DANUBIAN)
  217.             retVal = True;
  218.     };
  219.     return retVal;
  220. };
  221.  
  222. procedure MacedonianFlankingPosAcheived(hex)
  223. {
  224.     var unit, retVal, n;
  225.  
  226.     unit = HexOccupancy(hex);
  227.     retVal = False;
  228.  
  229.     if (unit != -1)
  230.     {
  231.         n = Query(NATION, unit);
  232.         if (n == MACEDONIAN)
  233.             retVal = True;
  234.     };
  235.     return retVal;
  236. };
  237.  
  238. procedure GreekFlankingPosAcheived(hex)
  239. {
  240.     var unit, retVal, n;
  241.  
  242.     unit = HexOccupancy(hex);
  243.     retVal = False;
  244.  
  245.     if (unit != -1)
  246.     {
  247.         n = Query(NATION, unit);
  248.         if (n == GREEK)
  249.             retVal = True;
  250.     };
  251.     return retVal;
  252. };
  253.  
  254. procedure ScythianFlankingPosAcheived(hex)
  255. {
  256.     var unit, retVal, n;
  257.  
  258.     unit = HexOccupancy(hex);
  259.     retVal = False;
  260.  
  261.     if (unit != -1)
  262.     {
  263.         n = Query(NATION, unit);
  264.         if (n == SCYTHIAN)
  265.             retVal = True;
  266.     };
  267.     return retVal;
  268. };
  269.  
  270. procedure DoNothing()
  271. {
  272. };
  273.  
  274. procedure GetUnitsOutOfRange(list)
  275. {
  276.     var unit, numOutOfRange;
  277.  
  278.     GroupListReset();
  279.     numOutOfRange = 0;
  280.     unit = GroupListGetNext();
  281.     while (unit != -1)
  282.     {
  283.         if (NOT InCommandRange(unit))
  284.         {
  285.             AddToList(list, unit);
  286.             numOutOfRange = numOutOfRange+1;
  287.         };
  288.         unit = GroupListGetNext();
  289.     };
  290.     return numOutOfRange;
  291. };
  292.  
  293. procedure GetUnitsInRange(list)
  294. {
  295.     var unit, numInRange;
  296.  
  297.     GroupListReset();
  298.     numInRange = 0;
  299.     unit = GroupListGetNext();
  300.     while (unit != -1)
  301.     {
  302.         if (InCommandRange(unit))
  303.         {
  304.             AddToList(list, unit);
  305.             numInRange = numInRange+1;
  306.         };
  307.         unit = GroupListGetNext();
  308.     };
  309.     return numInRange;
  310. };
  311.  
  312. ' This procedure will tell how many of the units are engaged in battle.
  313. ' The definition of "engaged in battle" means if someone is in his ZOC OR
  314. ' he is in someone else's ZOC.
  315. procedure GetUnitsEngagedInBattle(list)
  316. {
  317.     var unit, nation, numEngagedInBattle, surroundingHexes, zocHexes, hex,
  318.          enemy, enemyNation, added, unitHex, leader, isLeader;
  319.  
  320.     GroupListReset();
  321.     numEngagedInBattle = 0;
  322.     leader = GetLeader();
  323.     watch "Leader = " leader;
  324.     unit = GroupListGetNext();
  325.     if (unit == leader)
  326.         unit = GroupListGetNext();
  327.     while (unit != -1)
  328.     {
  329.         nation = Query(NATION, unit);
  330.         added = False;
  331.         unitHex = Query(REGION_NUM, unit);
  332.         ' First, check to see if he has someone in his ZOC.
  333.         zocHexes = GetList();
  334.         AssignList(zocHexes, 0, unit);    ' The 0 stands for ZOC hexes.
  335.         ResetList(zocHexes);
  336.         hex = GetNextInList(zocHexes);
  337.         while ((hex!=-1) AND (NOT added))
  338.         {
  339.             enemy = HexOccupancy(hex);
  340.             if (enemy != -1)
  341.             {
  342.                 enemyNation = Query(NATION, enemy);
  343.                 if (enemyNation != nation)
  344.                 {
  345.                     ' Found an enemy in his ZOC... add him to the list.
  346.                     AddToList(list, unit);
  347.                     added = True;
  348.                     numEngagedInBattle = numEngagedInBattle + 1;
  349.                 };
  350.             };
  351.             hex = GetNextInList(zocHexes);
  352.         };
  353.         ' ReleaseList(zocHexes);
  354.         ' Now check to see if anyone has him in his ZOC.
  355.         surroundingHexes = GetList();
  356.         AssignList(surroundingHexes, 5, unit);    ' The 5 stands for surrounding hexes.
  357.         ResetList(surroundingHexes);
  358.         hex = GetNextInList(surroundingHexes);
  359.         while ((hex != -1) AND (NOT added))
  360.         {
  361.             enemy = HexOccupancy(hex);
  362.             if (enemy != -1)
  363.             {
  364.                 enemyNation = Query(NATION, enemy);
  365.                 if (enemyNation != nation)
  366.                 {
  367.                     isLeader = IsLeader(enemy);
  368.                     if (NOT isLeader)
  369.                     {
  370.                         ClearList(zocHexes);
  371.                         AssignList(zocHexes, 0, enemy);    ' The 0 stands for ZOC hexes
  372.                         ResetList(zocHexes);
  373.                         if (IsMemberOf(zocHexes, unitHex))
  374.                         {
  375.                             AddToList(list, unit);
  376.                             added = True;
  377.                             numEngagedInBattle = numEngagedInBattle + 1;
  378.                         };
  379.                     };
  380.                 };
  381.             };
  382.             hex = GetNextInList(surroundingHexes);
  383.         };
  384.         ' ReleaseList(surroundingHexes);
  385.         unit = GroupListGetNext();
  386.         if (unit == leader)
  387.             unit = GroupListGetNext();
  388.     };
  389.     return numEngagedInBattle;
  390. };
  391.  
  392. procedure ParePathListDown(pathList, destHex)
  393. {
  394.     var path, hex, shortestDist, d, tempPath, tPath;
  395.  
  396.     d = SizeOfList(pathList);
  397.     ResetList(pathList);
  398.     shortestDist = 100;
  399.     path = GetNextInList(pathList);
  400.     while (path!=-1)
  401.     {
  402.         hex = GetLast(path);
  403.         d = Distance(hex, destHex);
  404.         if (d<shortestDist)
  405.         {
  406.             shortestDist = d;
  407.             ' Remove all lists up to this point.
  408.             ResetList(pathList);
  409.             tempPath = GetNextInList(pathList);
  410.             while (tempPath != path)
  411.             {
  412.                 tPath = tempPath;
  413.                 tempPath = GetNextInList(pathList);
  414.                 RemoveFromList(pathList, tPath);
  415.                 ' ReleaseList(tPath);
  416.             };
  417.             ResetList(pathList);
  418.             tPath = -1;
  419.         }
  420.         else
  421.         {
  422.             if (d<shortestDist)
  423.                 tPath = path;
  424.         };
  425.         path = GetNextInList(pathList);
  426.         if (tPath != -1)
  427.         {
  428. '                RemoveFromList(pathList, tPath);
  429. '                ReleaseList(tPath);
  430.         };
  431.     };
  432.     d = SizeOfList(pathList);
  433.     watch "Size of pathList: " d;
  434. };
  435.  
  436. ' This procedure looks at the current units that can move, weights their
  437. ' paths and choose which unit to move.  The units that are unable to move
  438. ' need to be passed into the unitsUnableToMove.  This functions should only
  439. ' be called when the conditions are clear (no unit in the group is in
  440. ' battle).  If a unit cannot move because his frontal hexes are covered (by
  441. ' friendlies), he is also not considered.
  442. ' If a unit is forced into a non-clear path, the most advantageous unit is
  443. ' moved to the most advantageous hex and assigned to combat.  After that,
  444. ' this routine should NOT be called again!
  445. procedure weightAndMove(unitsUnableToMove, destHex)
  446. {
  447.     var closestUnit, unitList, unitLookingAt, movementRemaining, movementAllowance,
  448.          whichUnitToMove, unitHex, closestDist, distance, correctFacing,
  449.          dir, retVal, potentialHexToAttack, canRotate, didAttack;
  450.  
  451.     write "Here in weightAndMove";
  452.     ' First, create a list of units that can move.  This involves checking
  453.     ' the group list and NOT adding units in the "unitsUnableToMove" list
  454.     ' and also excluding units that have already moved by this leader.  This
  455.     ' little routine also includes units that have friendlies in their
  456.     ' frontal hexes
  457.     closestUnit = -1;        ' Illegal unit
  458.     closestDist = 100;    ' No one will be this far away.
  459.     GroupListReset();
  460.     unitList = GetList();
  461.     unitLookingAt = GroupListGetNext();
  462.     while (unitLookingAt != -1)
  463.     {
  464.         if (IsMemberOf(unitsUnableToMove, unitLookingAt) == FALSE)
  465.         {
  466.             movementRemaining = Query(5, unitLookingAt);
  467.             movementAllowance = Query(4, unitLookingAt);
  468.             if (movementRemaining == movementAllowance)
  469.             {
  470.                 if (CanMove(unitLookingAt))
  471.                 {
  472.                     AddToList(unitList, unitLookingAt);
  473.                     unitHex = Query(REGION_NUM, unitLookingAt);
  474.                     distance = Distance(unitHex, destHex);
  475.                     if (distance < closestDist)
  476.                     {
  477.                         watch "This unit is closest to the destination: " unitLookingAt;
  478.                         watch "His distance to the destination is " distance;
  479.                         closestUnit = unitLookingAt;
  480.                         closestDist = distance;
  481.                     };
  482.                 };
  483.             };
  484.         };
  485.         unitLookingAt = GroupListGetNext();
  486.     };
  487.  
  488.     ' Check to see if there were any legal units to move.  If not, then they
  489.     ' are (probably) out of range.  Move the leader...
  490.     if (closestUnit == -1)
  491.     {
  492.         write "No more units to move... moving the leader.";
  493.         closestUnit = GetLeader();
  494.         retVal = MoveLeader();
  495.         if (retVal == ALREADY_MOVED)
  496.         {
  497.             ' If I'm in here, that means that there were no more units within range
  498.             ' to move before and after the leader movement.
  499.             FinishLeader();
  500.             return MOVE_SUCCESS;
  501.         };
  502.         if (retVal == 0)
  503.         {
  504.             ' If I'm in here, that means there were no legal moves for the leader
  505.          ' and he couldn't move anyone else, so here it ends.
  506.             FinishLeader();
  507.          return MOVE_SUCCESS;
  508.         };
  509.         return retVal;
  510.    };
  511.  
  512.     ' I have the closest unit now.  See if he is facing the right direction.
  513.     ' If he isn't, rotate him so he is facing the right direction.
  514.    unitHex = Query(REGION_NUM, closestUnit);
  515.     correctFacing = IsInGeneralDir(closestUnit, destHex);
  516.     if (correctFacing == FALSE)
  517.     {
  518.         dir = Direction(unitHex, destHex);
  519.         canRotate = CanRotate(closestUnit, dir);
  520.         if (canRotate)
  521.         {
  522.             retVal = Rotate(closestUnit, dir);
  523.             if (retVal == OW_MOVE)
  524.                 return MOVE_SUCCESS;
  525.         };
  526.     };
  527.  
  528.     ' Now, see if there are any units that are capable of being attacked...
  529.     potentialHexToAttack = AnyoneToCombat(closestUnit);
  530.     if (potentialHexToAttack != -1)
  531.     {
  532.        watch "Found a hex to attack: " potentialHexToAttack;
  533.         retVal = MoveToward(potentialHexToAttack, closestUnit);
  534.         if (retVal == 0)
  535.         {
  536.             return closestUnit;
  537.         };
  538.         retVal = TurnToAttack(closestUnit);
  539.         if (retVal == OW_MOVE)
  540.         {
  541.             write "Turning to attack by there is OW involved.  Quitting.";
  542.             return MOVE_SUCCESS;
  543.         };
  544.         didAttack = AttackInZOC(closestUnit);
  545.         if (NOT didAttack)
  546.             ShootMissilesFar(closestUnit);
  547.         return MOVE_SUCCESS;
  548.     };
  549.     retVal = MoveToward(destHex, closestUnit);
  550.    ShootMissilesFar(closestUnit);
  551.     if (retVal == 0)
  552.         return closestUnit;
  553.     return MOVE_SUCCESS;
  554. };
  555.  
  556. procedure Beserk()
  557. {
  558.     var inRangeList, unit, dir, correctFacing, unitHex, hex, canRotate, isRouting,
  559.          noMoreUnits, retVal, f, newDir, didMove, didAttack, cohesionHits, tq,
  560.          diff, rallied, recovered;
  561.  
  562.     write "Now in Beserk procedure";
  563.     noMoreUnits = NoMoreUnitsToCommand();
  564.     if (noMoreUnits)
  565.     {
  566.         CommandOtherUnits();
  567.       return True;
  568.     };
  569.     inRangeList = GetList();
  570.     GetUnitsInRange(inRangeList);
  571.     ResetList(inRangeList);
  572.     unit = GetNextInList(inRangeList);
  573.     while (unit != -1)
  574.     {
  575.         isRouting = Query(ROUTING, unit);
  576.         if (isRouting == False)
  577.         {
  578.             ' Check to see if he is close to routing.  If he is, don't move him...
  579.             watch "Now looking at unit #" unit;
  580.             cohesionHits = Query(COHESION_HITS, unit);
  581.             tq = Query(TQ, unit);
  582.             diff = tq - cohesionHits;
  583.             if (diff <= 2)
  584.                 watch "Not ordering him to move.  He is close to routing..." diff
  585.             else
  586.             {
  587.                 hex = FindClosestEnemyToAttack(unit);
  588.                 watch "He can attack hex #" hex;
  589.                 if (hex != -1)
  590.                 {
  591.                     correctFacing = IsInGeneralDir(unit, hex);
  592.                     if (correctFacing == False)
  593.                     {
  594.                         write "The unit is NOT facing the correct direction";
  595.                         f = Query(FACING, unit);
  596.                         watch "His current facing: " f;
  597.                         unitHex = Query(REGION_NUM, unit);
  598.                         dir = Direction(unitHex, hex);
  599.                         watch "The direction to rotate to: " dir;
  600.                         canRotate = CanRotate(unit, dir);
  601.                         if (canRotate)
  602.                         {
  603.                             retVal = Rotate(unit, dir);
  604.                             if (retVal == OW_MOVE)
  605.                          return 1;
  606.                         };
  607.                     };
  608.                     didMove = MoveToward(hex, unit);
  609.                     newDir = TurnToAttack(unit);
  610.                     if (newDir == OW_MOVE)
  611.                     {
  612.                         write "Turning to attack (from Beserk) with OW.  Quitting.";
  613.                         return 1;
  614.                     };
  615.                watch "This unit about to (maybe) attack: " unit;
  616.                     'if (newDir != NO_MOVE)
  617.                         didAttack = AttackInZOC(unit);
  618.                     if (didAttack)
  619.                         watch "This unit DID attack: " unit
  620.                     else
  621.                    watch "This unit did NOT attack: " unit;
  622.                     if ((NOT didAttack) AND didMove)
  623.                         ShootMissilesFar(unit); 
  624.                     if (didMove OR didAttack)
  625.                         return 1;
  626.                 };
  627.             };
  628.         };
  629.         unit = GetNextInList(inRangeList);
  630.     };
  631.  
  632.     ' No one was or could be moved.  Check to see if anyone needs to be rallied
  633.     ' or restored with rally being given priority.
  634.     rallied = Rally();
  635.     if (rallied != -1)
  636.         return 1;
  637.     ' No one was rallied.  Now try restoring cohesion hits
  638.     recovered = RecoverUnits();
  639.     if (recovered == -1)
  640.     {
  641.         retVal = MoveLeader();
  642.         if (retVal == ALREADY_MOVED)
  643.             FinishLeader();
  644.         if (retVal == NO_MOVE)
  645.             FinishLeader();
  646.     };
  647. };
  648.  
  649. procedure MoveLeader()
  650. {
  651.     ' This procedure moves the leader.  It will look first to see if it can move
  652.     ' into the midst of his troops and have the majority of them be in command
  653.     ' range.
  654.     ' It will first look to see if the leader has moved before in this current
  655.     ' orders phase.  If he has, it will return the ALREADY_MOVED constant.
  656.  
  657.     var aveX, aveY, hex, unit, numUnits, totalX, totalY, retVal, leader;
  658.     leader = GetLeader();
  659.  
  660.     retVal = CanBeOrdered(leader);
  661.     if (retVal == False)
  662.         return ALREADY_MOVED;
  663.  
  664.     ' First, get the average x and y hexes.
  665.     totalX = 0;
  666.     totalY = 0;
  667.     numUnits = 0;
  668.     GroupListReset();
  669.     unit = GroupListGetNext();
  670.     while (unit != -1)
  671.     {
  672.         hex = Query(REGION_NUM, unit);
  673.         if (hex != -1)
  674.         {
  675.             totalX = totalX + hex/100;
  676.             totalY = totalY + (hex - (hex/100)*100);
  677.             numUnits = numUnits + 1;
  678.         };
  679.         unit = GroupListGetNext();
  680.     };
  681.     ' Rather than just returning, the leader should detect that it has no units
  682.     ' that are surviving and go and try to help with another leader.  But, for
  683.     ' now (2/27/97), it is the way it is...
  684.     if (numUnits==0)
  685.        return 0;
  686.     aveX = totalX/numUnits;
  687.     aveY = totalY/numUnits;
  688.     hex = aveX*100+aveY;
  689.     retVal = MoveToward(hex, leader);
  690.    return retVal;
  691. };
  692.  
  693. procedure AttackWithSkirmishers();
  694.  
  695. procedure GenericMove(hex)
  696. {
  697.     var outOfRangeList, battlingList, unitRallied, unitRecovered, noMoreUnits,
  698.          retVal, done;
  699.  
  700.     noMoreUnits = NoMoreUnitsToCommand();
  701.     if (noMoreUnits)
  702.     {
  703.         CommandOtherUnits();
  704.         return True;
  705.     };
  706.     watch "Here in GenericMove and moving to hex " hex;
  707.     unitRallied = Rally();
  708.     if (unitRallied != -1)
  709.     {
  710.         write "A unit was rallied from GenericMove";
  711.         return 1;
  712.     };
  713.     unitRecovered = PartialRecover();
  714.     if (unitRecovered)
  715.     {
  716.         write "A unit was recovered";
  717.         return 1;
  718.     };
  719.     outOfRangeList = GetList();
  720.     battlingList = GetList();
  721.     GetUnitsOutOfRange(outOfRangeList);
  722.     GetUnitsEngagedInBattle(battlingList);
  723.  
  724.     ' This loop will (should) insure that the A/I leaders will use all of their
  725.     ' commands.
  726.     done = False;
  727.     while (NOT done)
  728.     {
  729.         retVal = weightAndMove(outOfRangeList, hex);
  730.         if (retVal >= 0)    ' This indicates that the unit # could NOT move...
  731.         {
  732.             AddToList(outOfRangeList, retVal);
  733.             watch "Could not move this unit: " retVal;
  734.         };
  735.         if (retVal == MOVE_SUCCESS)
  736.         {
  737.             done = True;
  738.             write "Successfully moved a unit in GenericMove";
  739.         };
  740.     };
  741. };
  742.  
  743. procedure AttackWithSkirmishers()
  744. {
  745.     ' Just end the leader for right now.
  746.     write "Finishing the leader from inside of AttackWithSkirmishers";
  747.     FinishLeader();
  748.     return 1;
  749. };
  750.  
  751. procedure AttackInZOC(movingUnit)
  752. {
  753.     var zocHexes, unit, hex, enemy;
  754.  
  755.     zocHexes = GetList();
  756.     AssignList(zocHexes, ZOC_HEXES, movingUnit);
  757.     ResetList(zocHexes);
  758.     hex = GetNextInList(zocHexes);
  759.     while (hex!=-1)
  760.     {
  761.         unit = HexOccupancy(hex);
  762.         if (unit != -1)
  763.         {
  764.             enemy = IsEnemy(movingUnit, unit);
  765.             Attack(movingUnit, hex);
  766.             ShootMissiles(movingUnit);
  767.             return 1;
  768.         };
  769.         hex = GetNextInList(zocHexes);
  770.     };
  771.    return 0;
  772. };
  773.  
  774. procedure ShootMissiles(shootingUnit)
  775. {
  776.     var zocHexes, unit, hex, enemy, numMissiles;
  777.     if (Query(MISSILE_CAPABLE, shootingUnit) == 0)
  778.     {
  779.         write "This unit CANNOT fire any missiles";
  780.         return 0;
  781.     };
  782.     write "This unit CAN shoot missiles";
  783.     numMissiles = Query(MISSILES_REMAINING, shootingUnit);
  784.     if (numMissiles == 0)
  785.     {
  786.         write "This unit is out of missiles so he will not shoot";
  787.       return 0;
  788.     };
  789.     ' Look in his ZOC and just see if he can shoot somebody...
  790.     zocHexes = GetList();
  791.     AssignList(zocHexes, ZOC_HEXES, shootingUnit);
  792.     ResetList(zocHexes);
  793.     hex = GetNextInList(zocHexes);
  794.     while (hex!=-1)
  795.     {
  796.         unit = HexOccupancy(hex);
  797.         if (unit != -1)
  798.         {
  799.             enemy = IsEnemy(shootingUnit, unit);
  800.             if (enemy)
  801.             {
  802.                 Fire(shootingUnit, hex);
  803.                 return 1;
  804.             };
  805.         };
  806.         hex = GetNextInList(zocHexes);
  807.     };
  808.     return 0;
  809. };
  810.  
  811. procedure ShootMissilesFar(unitToFire)
  812. {
  813.     var hexToFireAt, canFire;
  814.  
  815.     canFire = Query(MISSILE_CAPABLE, unitToFire);
  816.     if (canFire)
  817.     {
  818.         hexToFireAt = FindClosestEnemyToFire(unitToFire);
  819.         if (hexToFireAt != -1)
  820.         {
  821.             Fire(unitToFire, hexToFireAt);
  822.             return True;
  823.         };
  824.     };
  825.     return False;
  826. };
  827.  
  828. procedure Defend(hexToDefend)
  829. {
  830.     ' First, get a list of units in range and a list of units out of range.
  831.     var retVal, noMoreUnits, unit, legalUnits;
  832.  
  833.     write "Here in Defend";
  834.     noMoreUnits = NoMoreUnitsToCommand();
  835.     if (noMoreUnits)
  836.     {
  837.         CommandOtherUnits();
  838.       return True;
  839.     };
  840.  
  841.     retVal = Rally();
  842.     if (retVal != -1)
  843.         return 1;
  844.  
  845.     ' Look for units within 3 hits of routing... (excepting units that only have
  846.     ' 3 TQ points).
  847.     write "Couldn't find any units to rally!";
  848.     retVal = PartialRecover();
  849.     if (retVal)
  850.        return 1;
  851.  
  852.     write "Couldn't find a unit to recover...  now looking to rotate a unit...";
  853.     retVal = TurnToDefend();
  854.     if (retVal == True)
  855.         return 1;
  856.  
  857.     write "Couldn't find a unit to turn to defend himself... now trying to fire missiles...";
  858.     legalUnits = GetList();
  859.     GetUnitsToCommand(legalUnits);
  860.     unit = GetNextInList(legalUnits);
  861.     while (unit != -1)
  862.     {
  863.         retVal = ShootMissilesFar(unit);
  864.         if (retVal)
  865.             return 1;
  866.         unit = GetNextInList(legalUnits);
  867.    };
  868.  
  869.     retVal = RecoverUnits();
  870.     if (retVal == -1)
  871.         FinishLeader();
  872. };
  873.  
  874. procedure Rally()
  875. {
  876.     ' This function attempts to rally anyone in the leader's range.
  877.     ' The return value is 1 if someone was rallied and 0 if not.
  878.  
  879.     var outOfRangeUnits, numUnitsOutOfRange, routingUnitsInRange, unit, notInRange,
  880.          routing, retVal;
  881.  
  882.     outOfRangeUnits = GetList();
  883.     numUnitsOutOfRange = GetUnitsOutOfRange(outOfRangeUnits);
  884.  
  885.    retVal = 0;
  886.    write "Here in Rally";
  887.     ' Get a list of units that are in range and routing...
  888.     routingUnitsInRange = GetList();
  889.     GroupListReset();
  890.     unit = GroupListGetNext();
  891.     while (unit != -1)
  892.     {
  893.         notInRange = IsMemberOf(outOfRangeUnits, unit);
  894.         routing = False;
  895.         if (NOT notInRange)
  896.         {
  897.             watch "Looking at unit " unit;
  898.             routing = Query(ROUTING, unit);
  899.             if (routing)
  900.                 write "He IS routing"
  901.             else
  902.                 write "He is NOT routing";
  903.         };
  904.         if (routing)
  905.         {
  906.             watch "Found a routing unit: " unit;
  907.             retVal = AttemptToRally(unit);
  908.             return retVal;
  909.         };
  910.         unit = GroupListGetNext();
  911.     };
  912.     write "Couldn't find any units to rally!";
  913.    return -1;
  914. };
  915.  
  916. procedure PartialRecover()
  917. {
  918.     ' Find any unit that is within 3 cohesion hits of routing and recover him
  919.  
  920.     var unitsOutOfRange, numUnitsOutOfRange, notInRange, unit, tq, cohesionHit,
  921.          difference, canOrder, isRouting;
  922.  
  923.     write "Here in PartialRecover";
  924.     unitsOutOfRange = GetList();
  925.     numUnitsOutOfRange = GetUnitsOutOfRange(unitsOutOfRange);
  926.     GroupListReset();
  927.     unit = GroupListGetNext();
  928.     while (unit!=-1)
  929.     {
  930.         notInRange = IsMemberOf(unitsOutOfRange, unit);
  931.         canOrder = CanBeOrdered(unit);
  932.         if ((NOT notInRange) AND canOrder)
  933.         {
  934.             isRouting = Query(ROUTING, unit);
  935.             if (NOT isRouting)
  936.             {
  937.                 cohesionHit = Query(COHESION_HIT, unit);
  938.                 tq = Query(TROOP_Q, unit);
  939.                 difference = tq-cohesionHit;
  940.                 if ( (difference <= 3) AND (cohesionHit > 0))
  941.                 {
  942.                     Recover(unit);
  943.                     watch "Recovered unit: " unit;
  944.                     return 1;
  945.                 };
  946.             };
  947.         };
  948.       unit = GroupListGetNext();
  949.     };
  950.     return 0;
  951. };
  952.  
  953. procedure RecoverUnits()
  954. {
  955.     ' Find all the units within range and recover he who has the most cohesion
  956.     ' hits.
  957.  
  958.     var unitsOutOfRange, numUnitsOutOfRange, notInRange, unit, highUnit,
  959.          highCH, cohesionHit, isRouting;
  960.  
  961.     write "Here in RecoverUnits";
  962.     unitsOutOfRange = GetList();
  963.     numUnitsOutOfRange = GetUnitsOutOfRange(unitsOutOfRange);
  964.     highCH = 0;
  965.     highUnit = -1;
  966.     GroupListReset();
  967.     unit = GroupListGetNext();
  968.     while (unit != -1)
  969.     {
  970.         notInRange = IsMemberOf(unitsOutOfRange, unit);
  971.         if (NOT notInRange)
  972.         {
  973.             watch "Looking at unit " unit;
  974.             isRouting = Query(ROUTING, unit);
  975.             if (NOT isRouting)
  976.             {
  977.                 cohesionHit = Query(COHESION_HIT, unit);
  978.                 if (cohesionHit > highCH)
  979.                 {
  980.                     highCH = cohesionHit;
  981.                     highUnit = unit;
  982.                     watch "New high cohesion hit: " highCH;
  983.                 };
  984.             };
  985.         };
  986.         unit = GroupListGetNext();
  987.     };
  988.     if (highUnit == -1)
  989.     {
  990.         write "There weren't any units that needed recovering...";
  991.         return -1;
  992.     };
  993.     Recover(highUnit);
  994.     return highUnit;
  995. };
  996.  
  997. procedure RecoverAnyUnit()
  998. {
  999.     ' Find all the units within range and recover he who has the most cohesion
  1000.     ' hits.
  1001.  
  1002.     var unit, highUnit, unitList, leader,
  1003.          highCH, cohesionHit, isRouting;
  1004.  
  1005.     write "Here in RecoverUnits";
  1006.     unitList = GetList();
  1007.     highCH = 0;
  1008.     highUnit = -1;
  1009.    leader = GetLeader();
  1010.     AssignList(unitList, IN_RANGE_UNITS, leader);
  1011.     unit = GetNextInList(unitList);
  1012.     while (unit != -1)
  1013.     {
  1014.         watch "Looking at unit " unit;
  1015.         isRouting = Query(ROUTING, unit);
  1016.         if (NOT isRouting)
  1017.         {
  1018.             cohesionHit = Query(COHESION_HIT, unit);
  1019.             if (cohesionHit > highCH)
  1020.             {
  1021.                 highCH = cohesionHit;
  1022.                 highUnit = unit;
  1023.                 watch "New high cohesion hit: " highCH;
  1024.             };
  1025.         };
  1026.         unit = GetNextInList(unitList);
  1027.     };
  1028.     if (highUnit == -1)
  1029.     {
  1030.         write "There weren't any units that needed recovering...";
  1031.         return -1;
  1032.     };
  1033.     Recover(highUnit);
  1034.     return highUnit;
  1035. };
  1036.  
  1037. procedure EnemyWithinRangeOfGroup(radius)
  1038. {
  1039.     var unit, inRange;
  1040.  
  1041.     GroupListReset();
  1042.     unit = GroupListGetNext();
  1043.     while (unit!=-1)
  1044.     {
  1045.         inRange = EnemyWithinRange(unit, radius);
  1046.         if (inRange)
  1047.             return True;
  1048.         unit = GroupListGetNext();
  1049.     };
  1050. };
  1051.  
  1052. procedure CommandOtherUnits()
  1053. {
  1054.     var hexToMoveTo, unitToMoveTowards, initiative, leader, isRouting, inRange,
  1055.          moveValue, retVal;
  1056.  
  1057.     write "Here in CommandOtherUnits";
  1058.     hexToMoveTo = FindHurtingUnit();
  1059.     if (hexToMoveTo == -1)
  1060.     {
  1061.         write "Couldn't find any units to Rally or Restore.  Now finishing the leader.";
  1062.         FinishLeader();
  1063.         return 0;
  1064.     };
  1065.    watch "Found this hex to move to: " hexToMoveTo;
  1066.     unitToMoveTowards = HexOccupancy(hexToMoveTo);
  1067.    leader = GetLeader();
  1068.     initiative = Query(INITIATIVE, leader);
  1069.     inRange = InCommandRange(unitToMoveTowards);
  1070.     if (NOT inRange)
  1071.     {
  1072.        write "The unit was NOT in range so the leader is being moved";
  1073.         moveValue = MoveToward(hexToMoveTo, leader);
  1074.         if (moveValue == 0)
  1075.         {
  1076.             retVal = RecoverAnyUnit();
  1077.             if (retVal == -1)
  1078.                 FinishLeader();
  1079.         };
  1080.         return 1;
  1081.     };
  1082.     if (initiative>=4)
  1083.     {
  1084.         isRouting = Query(ROUTING, unitToMoveTowards);
  1085.         if (isRouting)
  1086.         {
  1087.             AttemptToRally(unitToMoveTowards);
  1088.             return 1;
  1089.         };
  1090.     };
  1091.     Recover(unitToMoveTowards);
  1092. };
  1093.  
  1094. procedure NoMoreUnitsToCommand()
  1095. {
  1096.     var groupListSize;
  1097.  
  1098.     groupListSize = GroupListGetSize();
  1099.     if (groupListSize == 0)
  1100.         return True;
  1101.     return False;
  1102. };
  1103.  
  1104. procedure TurnToDefend()
  1105. {
  1106.     var unitsToCommand, unit, enemyHex, hex, d, shortDistance, highUnit,
  1107.          high, highEnemyHex, highHex, retVal;
  1108.  
  1109.     write "Here in TurnToDefend";
  1110.     unitsToCommand = GetList();
  1111.     GetUnitsToCommand(unitsToCommand);
  1112.     shortDistance = 999;
  1113.     highUnit = -1;
  1114.     ResetList(unitsToCommand);
  1115.     unit = GetNextInList(unitsToCommand);
  1116.     while (unit != -1)
  1117.     {
  1118.         hex = Query(REGION_NUM, unit);
  1119.         enemyHex = FindClosestEnemyToAttack(unit);
  1120.         retVal = IsInGeneralDir(unit, enemyHex);
  1121.         if (retVal == False)
  1122.         {
  1123.             d = Distance(enemyHex, hex);
  1124.             if (shortDistance > d)
  1125.             {
  1126.                 shortDistance = d;
  1127.                 highUnit = unit;
  1128.                 highHex = hex;
  1129.             highEnemyHex = enemyHex;
  1130.             };
  1131.         };
  1132.         unit = GetNextInList(unitsToCommand);
  1133.     };
  1134.     if (highUnit != -1)
  1135.     {
  1136.        d = Direction(highHex, highEnemyHex);
  1137.         retVal = CanRotate(highUnit, d);
  1138.         if (retVal == False)
  1139.         {
  1140.             watch "Unit cannot rotate for some reason: " highUnit;
  1141.             return False;
  1142.         };
  1143.         Rotate(highUnit, d);
  1144.         watch "Rotated this unit: " highUnit;
  1145.         ' Now check to see if he can fire any missiles...
  1146.         return True;
  1147.     };
  1148.    return False;
  1149. };
  1150.  
  1151. procedure GetUnitsToCommand(legalList)
  1152. {
  1153.     var unitsOutOfRange, unit, illegalUnits, retVal;
  1154.  
  1155.     GroupListReset();
  1156.     unit = GroupListGetNext();
  1157.     while (unit != -1)
  1158.     {
  1159.         AddToList(legalList, unit);
  1160.         unit = GroupListGetNext();
  1161.     };
  1162.  
  1163.     ' First, remove all units that are out of range...
  1164.     unitsOutOfRange = GetList();
  1165.     GetUnitsOutOfRange(unitsOutOfRange);
  1166.     unit = GetNextInList(unitsOutOfRange);
  1167.     while (unit != -1)
  1168.     {
  1169.         RemoveFromList(legalList, unit);
  1170.         unit = GetNextInList(unitsOutOfRange);
  1171.     };
  1172.  
  1173.     ' Now, remove units that cannot be commanded...
  1174.     ResetList(legalList);
  1175.     illegalUnits = GetList();
  1176.     unit = GetNextInList(legalList);
  1177.     while (unit != -1)
  1178.     {
  1179.         retVal = CanBeOrdered(unit);
  1180.         if (retVal == False)
  1181.             AddToList(illegalUnits, unit);
  1182.         unit = GetNextInList(legalList);
  1183.     };
  1184.     ResetList(illegalUnits);
  1185.     unit = GetNextInList(illegalUnits);
  1186.     while (unit != -1)
  1187.     {
  1188.         RemoveFromList(legalList, unit);
  1189.       unit = GetNextInList(illegalUnits);
  1190.     };
  1191.    return 1;
  1192. };
  1193.